Good. So, as I said,

we're going to look into the basics.

We're going to look at logic programming prologue.

We're going to look at rational agents

and complexity, I think, at some point.

Why do we need complexity theory?

We're going to start with logic.

This is kind of the break where after the guy in front tells you

lots of fascinating stories and asks

interesting questions to have a lot of beer over and so on.

Then, kind of the curve of the lecture breaks.

Then you're taught prologue.

Okay. That's first search.

Oh, God. But we have to do the technical bits too.

So, that's what starts now.

Okay. Yes, two are already leaving.

Okay. That's fine.

Good. Logic programming.

In particular, we're going to use prologue

being one of the original logic programming language.

We have three big programming paradigms in computer science,

which are imperative programming, functional programming,

and logic programming or declarative programming.

Object-oriented programming is not one of them.

It's just a particular wrinkle on imperative programming.

Okay. Imperative programming,

the typical thing is C or Java,

and you can add types to it or not.

You can add classes and inheritance or not.

The really important thing is what you do to your variables.

An imperative programming, something like x equals x plus one,

is the thing to do.

The idea is that you have these variables,

they have state,

and you can shove things in there.

Of course, if you think of this mathematically,

it makes no sense.

Never is x equal x plus one.

Just try it. Three equals four. No.

So imperative programs,

even though they're extremely natural,

if you think about them as giving instructions,

especially if you write it like this,

mathematically, it still doesn't make sense.

They're hard to reason about.

Very difficult.

Think about a program verification system

verifying functional programs is much, much, much, much easier

than verifying imperative programs.

This is not something you can do in declarative